2025년 9월 15일한국어

Python의 ast 모듈을 사용하여 추상 구문 트리를 조작하는 방법을 알아보세요. Python 코드를 프로그래밍 방식으로 분석, 수정 및 생성하는 방법을 배웁니다.

Python Ast 모듈: 추상 구문 트리 조작 완벽 해설

Python ast 모듈은 Python 코드의 추상 구문 트리(AST)와 상호 작용할 수 있는 강력한 방법을 제공합니다. AST는 소스 코드의 구문 구조를 트리 형태로 표현한 것으로, Python 코드를 프로그래밍 방식으로 분석, 수정하고 심지어 생성할 수 있게 해줍니다. 이를 통해 코드 분석 도구, 자동 리팩토링, 정적 분석, 사용자 정의 언어 확장 등 다양한 애플리케이션을 개발할 수 있습니다. 이 문서에서는 ast 모듈의 기본 사항을 안내하고, 실용적인 예제와 그 기능에 대한 통찰력을 제공합니다.

추상 구문 트리(AST)란 무엇입니까?

ast 모듈에 대해 자세히 알아보기 전에 추상 구문 트리가 무엇인지 이해해 봅시다. Python 인터프리터가 코드를 실행할 때 첫 번째 단계는 코드를 AST로 파싱하는 것입니다. 이 트리 구조는 함수, 클래스, 루프, 표현식, 연산자와 같은 코드의 구문 요소와 그 관계를 나타냅니다. AST는 공백이나 주석과 같은 불필요한 세부 사항을 버리고 필수적인 구조 정보에 집중합니다. 이러한 방식으로 코드를 표현함으로써 프로그램이 코드 자체를 분석하고 조작할 수 있게 되어 다양한 상황에서 매우 유용합니다.

`ast` 모듈 시작하기

ast 모듈은 Python 표준 라이브러리의 일부이므로 추가 패키지를 설치할 필요가 없습니다. 사용하려면 간단히 임포트하십시오:

            import ast

ast 모듈의 핵심 기능은 ast.parse()입니다. 이 함수는 Python 코드 문자열을 입력으로 받아 AST 객체를 반환합니다.

            code = """
def add(x, y):
    return x + y
"""

ast_tree = ast.parse(code)
print(ast_tree)

이것은 다음과 같은 것을 출력합니다: <_ast.Module object at 0x...>. 이 출력은 특별히 유익하지는 않지만 코드가 AST로 성공적으로 파싱되었음을 나타냅니다. 이제 ast_tree 객체는 파싱된 코드의 전체 구조를 포함합니다.

AST 탐색

AST의 구조를 이해하기 위해 ast.dump() 함수를 사용할 수 있습니다. 이 함수는 트리를 재귀적으로 탐색하고 각 노드의 자세한 표현을 출력합니다.

            code = """
def add(x, y):
    return x + y
"""

ast_tree = ast.parse(code)
print(ast.dump(ast_tree, indent=4))

출력은 다음과 같습니다:

            Module(
    body=[
        FunctionDef(
            name='add',
            args=arguments(
                posonlyargs=[],
                args=[
                    arg(arg='x', annotation=None, type_comment=None),
                    arg(arg='y', annotation=None, type_comment=None)
                ],
                kwonlyargs=[],
                kw_defaults=[],
                defaults=[]
            ),
            body=[
                Return(
                    value=BinOp(
                        left=Name(id='x', ctx=Load()),
                        op=Add(),
                        right=Name(id='y', ctx=Load())
                    )
                )
            ],
            decorator_list=[],
            returns=None,
            type_comment=None
        )
    ],
    type_ignores=[]
)

이 출력은 코드의 계층적 구조를 보여줍니다. 자세히 살펴보겠습니다:

Module: 전체 모듈을 나타내는 루트 노드입니다.
body: 모듈 내의 명령문 목록입니다.
FunctionDef: 함수 정의를 나타냅니다. 그 속성은 다음과 같습니다:

name: 함수 이름('add').
args: 함수의 인수.

arguments: 함수의 인수에 대한 정보를 포함합니다.
arg: 단일 인수(예: 'x', 'y')를 나타냅니다.

body: 함수 본문(명령문 목록).
Return: return 문을 나타냅니다.

value: 반환되는 값.
BinOp: 이항 연산(예: x + y)을 나타냅니다.

left: 왼쪽 피연산자(예: 'x').
op: 연산자(예: 'Add').
right: 오른쪽 피연산자(예: 'y').

AST 탐색

ast 모듈은 AST를 탐색하기 위해 ast.NodeVisitor 클래스를 제공합니다. ast.NodeVisitor를 서브클래싱하고 그 메서드를 오버라이드함으로써 탐색 중에 특정 노드 유형을 처리할 수 있습니다. 이것은 코드 구조를 분석하거나, 특정 패턴을 식별하거나, 정보를 추출하는 데 유용합니다.

            import ast

class FunctionNameExtractor(ast.NodeVisitor):
    def __init__(self):
        self.function_names = []

    def visit_FunctionDef(self, node):
        self.function_names.append(node.name)

code = """
def add(x, y):
    return x + y

def subtract(x, y):
    return x - y
"""

ast_tree = ast.parse(code)

extractor = FunctionNameExtractor()
extractor.visit(ast_tree)

print(extractor.function_names)  # Output: ['add', 'subtract']

이 예제에서 FunctionNameExtractor는 ast.NodeVisitor에서 상속받고 visit_FunctionDef 메서드를 오버라이드합니다. 이 메서드는 AST의 각 함수 정의 노드에 대해 호출됩니다. 이 메서드는 함수 이름을 function_names 목록에 추가합니다. visit() 메서드는 AST 탐색을 시작합니다.

예제: 모든 변수 할당 찾기

            import ast

class VariableAssignmentFinder(ast.NodeVisitor):
    def __init__(self):
        self.assignments = []

    def visit_Assign(self, node):
        for target in node.targets:
            if isinstance(target, ast.Name):
                self.assignments.append(target.id)

code = """
x = 10
y = x + 5
message = "hello"
"""

ast_tree = ast.parse(code)

finder = VariableAssignmentFinder()
finder.visit(ast_tree)

print(finder.assignments)  # Output: ['x', 'y', 'message']

이 예제는 코드에서 모든 변수 할당을 찾습니다. visit_Assign 메서드는 각 할당 명령문에 대해 호출됩니다. 이 메서드는 할당의 대상을 반복하고, 대상이 단순 이름(ast.Name)인 경우 이름을 assignments 목록에 추가합니다.

AST 수정

ast 모듈은 AST를 수정할 수도 있습니다. 기존 노드를 변경하거나, 새 노드를 추가하거나, 노드를 완전히 제거할 수 있습니다. AST를 수정하려면 ast.NodeTransformer 클래스를 사용합니다. ast.NodeVisitor와 유사하게 ast.NodeTransformer를 서브클래싱하고 그 메서드를 오버라이드하여 특정 노드 유형을 수정합니다. 주요 차이점은 ast.NodeTransformer 메서드는 수정된 노드(또는 대체할 새 노드)를 반환해야 한다는 것입니다. 메서드가 None을 반환하면 노드는 AST에서 제거됩니다.

AST를 수정한 후에는 compile() 함수를 사용하여 다시 실행 가능한 Python 코드로 컴파일해야 합니다.

            import ast

class AddOneTransformer(ast.NodeTransformer):
    def visit_Num(self, node):
        return ast.Num(n=node.n + 1)

code = """
x = 10
y = 20
"""

ast_tree = ast.parse(code)

transformer = AddOneTransformer()
new_ast_tree = transformer.visit(ast_tree)

new_code = compile(new_ast_tree, '', 'exec')

# Execute the modified code
exec(new_code)

print(x)  # Output: 11
print(y)  # Output: 21

이 예제에서 AddOneTransformer는 ast.NodeTransformer에서 상속받고 visit_Num 메서드를 오버라이드합니다. 이 메서드는 각 숫자 리터럴 노드(ast.Num)에 대해 호출됩니다. 이 메서드는 값을 1씩 증가시킨 새 ast.Num 노드를 만듭니다. visit() 메서드는 수정된 AST를 반환합니다.

compile() 함수는 수정된 AST, 파일 이름(이 경우 <string>은 코드가 문자열에서 온 것임을 나타냄) 및 실행 모드(코드 블록을 실행하기 위한 'exec')를 사용합니다. 이는 exec() 함수를 사용하여 실행할 수 있는 코드 객체를 반환합니다.

예제: 변수 이름 바꾸기

            import ast

class VariableNameReplacer(ast.NodeTransformer):
    def __init__(self, old_name, new_name):
        self.old_name = old_name
        self.new_name = new_name

    def visit_Name(self, node):
        if node.id == self.old_name:
            return ast.Name(id=self.new_name, ctx=node.ctx)
        return node

code = """
def multiply_by_two(number):
    return number * 2

result = multiply_by_two(5)
print(result)
"""

ast_tree = ast.parse(code)

replacer = VariableNameReplacer('number', 'num')
new_ast_tree = replacer.visit(ast_tree)

new_code = compile(new_ast_tree, '', 'exec')

# Execute the modified code
exec(new_code)

이 예제는 변수 이름 'number'의 모든 인스턴스를 'num'으로 바꿉니다. VariableNameReplacer는 이전 이름과 새 이름을 인수로 사용합니다. visit_Name 메서드는 각 이름 노드에 대해 호출됩니다. 노드의 식별자가 이전 이름과 일치하면 새 이름과 동일한 컨텍스트(node.ctx)로 새 ast.Name 노드를 만듭니다. 컨텍스트는 이름이 사용되는 방식(예: 로드, 저장)을 나타냅니다.

AST에서 코드 생성

compile()을 사용하면 AST에서 코드를 실행할 수 있지만 코드를 문자열로 가져오는 방법은 제공하지 않습니다. AST에서 Python 코드를 생성하려면 astunparse 라이브러리를 사용할 수 있습니다. 이 라이브러리는 표준 라이브러리의 일부가 아니므로 먼저 설치해야 합니다:

            pip install astunparse

그런 다음 astunparse.unparse() 함수를 사용하여 AST에서 코드를 생성할 수 있습니다.

            import ast
import astunparse

code = """
def add(x, y):
    return x + y
"""

ast_tree = ast.parse(code)

generated_code = astunparse.unparse(ast_tree)

print(generated_code)

출력은 다음과 같습니다:

            def add(x, y):
    return (x + y)

참고: (x + y) 주위의 괄호는 올바른 연산자 우선 순위를 보장하기 위해 astunparse에서 추가됩니다. 이러한 괄호는 엄격하게 필요하지 않을 수 있지만 코드의 정확성을 보장합니다.

예제: 간단한 클래스 생성

            import ast
import astunparse

class_name = 'MyClass'
method_name = 'my_method'

# Create the class definition node
class_def = ast.ClassDef(
    name=class_name,
    bases=[],
    keywords=[],
    body=[
        ast.FunctionDef(
            name=method_name,
            args=ast.arguments(
                posonlyargs=[],
                args=[],
                kwonlyargs=[],
                kw_defaults=[],
                defaults=[]
            ),
            body=[
                ast.Pass()
            ],
            decorator_list=[],
            returns=None,
            type_comment=None
        )
    ],
    decorator_list=[]
)

# Create the module node containing the class definition
module = ast.Module(body=[class_def], type_ignores=[])

# Generate the code
code = astunparse.unparse(module)

print(code)

이 예제는 다음 Python 코드를 생성합니다:

            class MyClass:

    def my_method():
        pass

이것은 처음부터 AST를 빌드한 다음 거기에서 코드를 생성하는 방법을 보여줍니다. 이 접근 방식은 코드 생성 도구 및 메타 프로그래밍에 강력합니다.

`ast` 모듈의 실제 응용 프로그램

ast 모듈에는 다음과 같은 다양한 실제 응용 프로그램이 있습니다:

코드 분석: 스타일 위반, 보안 취약점 또는 성능 병목 현상에 대한 코드 분석. 예를 들어 대규모 프로젝트에서 코딩 표준을 시행하는 도구를 작성할 수 있습니다.
자동화된 리팩토링: 변수 이름 바꾸기, 메서드 추출 또는 코드를 변환하여 최신 언어 기능을 사용하는 등의 작업을 자동화합니다. rope와 같은 도구는 강력한 리팩토링 기능을 위해 AST를 활용합니다.
정적 분석: 실제로 실행하지 않고도 코드에서 잠재적인 오류 또는 버그를 식별합니다. pylint 및 flake8과 같은 도구는 AST 분석을 사용하여 문제를 감지합니다.
코드 생성: 템플릿 또는 사양에 따라 코드를 자동으로 생성합니다. 이것은 반복적인 코드를 만들거나 다른 플랫폼에 대한 코드를 생성하는 데 유용합니다.
언어 확장: Python 코드를 다른 표현으로 변환하여 사용자 정의 언어 확장 또는 도메인 특정 언어(DSL)를 만듭니다.
보안 감사: 잠재적으로 유해한 구조 또는 취약점에 대한 코드 분석. 이것은 안전하지 않은 코딩 사례를 식별하는 데 사용할 수 있습니다.

예제: 코딩 스타일 적용

프로젝트의 모든 함수 이름이 snake_case 규칙(예: my_function 대신 myFunction)을 따르도록 하고 싶다고 가정해 보겠습니다. ast 모듈을 사용하여 위반 여부를 확인할 수 있습니다.

            import ast
import re

class SnakeCaseChecker(ast.NodeVisitor):
    def __init__(self):
        self.errors = []

    def visit_FunctionDef(self, node):
        if not re.match(r'^[a-z]+(_[a-z]+)*$', node.name):
            self.errors.append(f"Function name '{node.name}' does not follow snake_case convention")

    def check_code(self, code):
        ast_tree = ast.parse(code)
        self.visit(ast_tree)
        return self.errors

# Example usage
code = """
def myFunction(x):
    return x * 2

def calculate_area(width, height):
    return width * height
"""

checker = SnakeCaseChecker()
errors = checker.check_code(code)

if errors:
    for error in errors:
        print(error)
else:
    print("No style violations found")

이 코드는 ast.NodeVisitor에서 상속받는 SnakeCaseChecker 클래스를 정의합니다. visit_FunctionDef 메서드는 함수 이름이 snake_case 정규식과 일치하는지 확인합니다. 그렇지 않으면 오류 메시지를 errors 목록에 추가합니다. check_code 메서드는 코드를 파싱하고 AST를 탐색하며 오류 목록을 반환합니다.

`ast` 모듈로 작업할 때의 모범 사례

AST 구조 이해: AST를 조작하기 전에 ast.dump()를 사용하여 해당 구조를 이해하는 데 시간을 투자하십시오. 이렇게 하면 작업해야 할 노드를 식별하는 데 도움이 됩니다.
ast.NodeVisitor 및 ast.NodeTransformer 사용: 이 클래스는 트리를 수동으로 탐색하지 않고도 AST를 탐색하고 수정하는 편리한 방법을 제공합니다.
철저한 테스트: AST를 수정할 때 변경 사항이 올바른지 확인하고 오류를 일으키지 않도록 코드를 철저히 테스트하십시오.
코드 생성에 astunparse 고려: compile()은 수정된 코드를 실행하는 데 유용하지만 astunparse는 AST에서 읽을 수 있는 Python 코드를 생성하는 방법을 제공합니다.
유형 힌트 사용: 유형 힌트는 특히 복잡한 AST 구조로 작업할 때 코드의 가독성과 유지 관리성을 크게 향상시킬 수 있습니다.
코드 문서화: 사용자 정의 AST 방문자 또는 변환기를 만들 때 각 메서드의 목적과 AST에 대한 변경 사항을 설명하기 위해 코드를 명확하게 문서화하십시오.

과제 및 고려 사항

복잡성: AST로 작업하는 것은 특히 더 큰 코드베이스의 경우 복잡할 수 있습니다. 다양한 노드 유형과 그 관계를 이해하는 것은 어려울 수 있습니다.
유지 관리: AST 구조는 Python 버전 간에 변경될 수 있습니다. 호환성을 보장하려면 다른 Python 버전으로 코드를 테스트하십시오.
성능: 대규모 AST를 탐색하고 수정하는 데 시간이 오래 걸릴 수 있습니다. 성능을 향상시키기 위해 코드를 최적화하는 것을 고려하십시오. 자주 액세스하는 노드를 캐싱하거나 더 효율적인 알고리즘을 사용하면 도움이 될 수 있습니다.
오류 처리: AST를 파싱하거나 조작할 때 오류를 정상적으로 처리하십시오. 사용자에게 유익한 오류 메시지를 제공하십시오.
보안: 특히 AST가 사용자 입력을 기반으로 하는 경우 AST에서 생성된 코드를 실행할 때 주의하십시오. 코드 삽입 공격을 방지하기 위해 입력을 삭제하십시오.

결론

Python ast 모듈은 Python 코드의 추상 구문 트리와 상호 작용할 수 있는 강력하고 유연한 방법을 제공합니다. AST 구조를 이해하고 ast.NodeVisitor 및 ast.NodeTransformer 클래스를 사용하면 Python 코드를 프로그래밍 방식으로 분석, 수정 및 생성할 수 있습니다. 이것은 코드 분석 도구에서 자동 리팩토링, 사용자 정의 언어 확장에 이르기까지 광범위한 응용 프로그램을 위한 문을 엽니다. AST로 작업하는 것이 복잡할 수 있지만 코드를 프로그래밍 방식으로 조작할 수 있다는 이점은 상당합니다. ast 모듈의 힘을 받아들여 Python 프로젝트에서 새로운 가능성을 열어보십시오.

Python Ast 모듈: 추상 구문 트리 조작 완벽 해설

추상 구문 트리(AST)란 무엇입니까?

ast 모듈 시작하기

AST 탐색

AST 탐색

예제: 모든 변수 할당 찾기

AST 수정

예제: 변수 이름 바꾸기

AST에서 코드 생성

예제: 간단한 클래스 생성

ast 모듈의 실제 응용 프로그램

예제: 코딩 스타일 적용

ast 모듈로 작업할 때의 모범 사례

과제 및 고려 사항

결론

`ast` 모듈 시작하기

`ast` 모듈의 실제 응용 프로그램

`ast` 모듈로 작업할 때의 모범 사례